package com.brave.base;

import com.alibaba.fastjson.JSONObject;
import com.brave.user.dto.RedisUserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.Optional;
import java.util.concurrent.TimeUnit;

/**
 * @UserName: BraveKing-wy
 * @DateTime: 2019/1/5 10:33
 * @Description: Redis工具类
 **/
@Component
public class RedisKit
{
    @Autowired
    private RedisTemplate redisTemplate;


    /**
     * 2019年8月23日 20:15:47
     * 校验用户是否合法
     * @param token
     * @return
     */
    public RedisUserInfo checkUserToken(String token)
    {
        String userInfoMsg = this.getValue(token);
        if("".equals(userInfoMsg))
        {
            return null;
        }else
        {
            return JSONObject.parseObject(userInfoMsg, RedisUserInfo.class);
        }
    }
    
    /**
     * 2019年1月5日 10:37:09
     * 保存临时键值
     * @param key 键
     * @param value 值
     * @param unit 单位
     * @param time 数量
     * @return
     */
    public boolean saveTempValue(String key, Object value, TimeUnit unit, int time)
    {
        ValueOperations operations = redisTemplate.opsForValue();
        try
        {
            if(value.getClass() == String.class)
            {
                operations.set(key, value, time, unit);
            }else
            {
                operations.set(key, JSONObject.toJSONString(value), time, unit);
            }
        }catch(Exception ex)
        {
            ex.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 2019年1月5日 10:39:34
     * 保存永久键值
     * @param key
     * @param value
     * @return
     */
    public boolean saveValue(String key, Object value)
    {
        ValueOperations operations = redisTemplate.opsForValue();
        try
        {
            if(value.getClass() == String.class)
            {
                operations.set(key, value);
            }else
            {
                operations.set(key, JSONObject.toJSONString(value));
            }
        }catch(Exception ex)
        {
            return false;
        }
        return true;
    }

    /**
     * 2019年1月5日 10:43:43
     * 以键取值
     * @param key
     * @return
     */
    public String getValue(String key)
    {
        ValueOperations operations = redisTemplate.opsForValue();
        try
        {
            Optional<Object> optional = Optional.of(operations.get(key));
            if(optional.isPresent())
            {
                return optional.get().toString();
            }else
            {
                return "";
            }
        }catch(Exception ex)
        {
            return "";
        }
    }

    /**
     * 2019年1月10日 10:45:34
     * 删除对应的键值对
     * @param key
     * @return
     */
    public boolean delValue(String key)
    {
        try
        {
            redisTemplate.delete(key);
            String value = this.getValue(key);
            if("".equals(value))
            {
                redisTemplate.delete(key);
            }
            return true;
        }catch(Exception ex)
        {
            return false;
        }
    }

    /**
     * 2019年1月16日 08:35:32
     * 获取Redis缓存剩余存活时间
     * @param key
     * @return
     */
    public long getLiveTimesByKey(String key)
    {
        //先获取对应的键值，如果有，那么返回存活时间，如果没有，那么返回0
        String resultInfo = this.getValue(key);
        if("".equals(resultInfo))
        {
            return 0;
        }else
        {
            long times = redisTemplate.getExpire(key);
            return times;
        }
    }
}